ArithmeticException.spec.js ➔ ??? - Code Metrics - Inspection of "Added ArithmeticException 'class'." - EgaLabs/node-ejsception - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 057e84...5972c1 )

by Esaú

created 2017-06-10 15:48 UTC

ArithmeticException.spec.js ➔ ??? B

↳ Parent: spec/ArithmeticException.spec.js

Complexity

Conditions	1
Paths	512

Size

Total Lines

195

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
c	1
b	0
f	0
nc	512
dl	0
loc	195
rs	7.0742
nop	0

1 Function

Rating	Name	Duplication	Size	Complexity
A	ArithmeticException.spec.js ➔ ... ➔ ???	0	3	1

How to fix Long Method

// spec/ArithmeticException.spec.js
"use strict";

// :: DEPENDENCIES

// load native dependencies
const path = require("path");

// load local dependencies
const root                = path.dirname(__dirname);
const Throwable           = require(path.join(root, "Throwable.js"));
const Exception           = require(path.join(root, "Exception.js"));
const RuntimeException    = require(path.join(root, "RuntimeException.js"));
const ArithmeticException = require(path.join(root, "ArithmeticException.js"));

// :: TESTING

// test the ArithmeticException 'class'
describe("ArithmeticException", () => {

    // :: INHERITED PROTOTYPE

    it("should inherit from 'Object'", () => {
        expect(new ArithmeticException()).toEqual(jasmine.any(Object));
    });

	it("should inherit from 'Throwable'", () => {
		expect(new ArithmeticException()).toEqual(jasmine.any(Throwable));
	});

	it("should inherit from 'Exception'", () => {
		expect(new ArithmeticException()).toEqual(jasmine.any(Exception));
	});

    it("should inherit from 'RuntimeException'", () => {
        expect(new ArithmeticException()).toEqual(jasmine.any(RuntimeException));
    });

	it("should have a prototype method named 'toString()'", () => {
		expect(ArithmeticException.prototype).toHaveMethod("toString");
	});

	it("should have a prototype method named 'native()'", () => {
		expect(ArithmeticException.prototype).toHaveMethod("native");
	});

	it("should have a prototype property string named 'name'", () => {
		expect(ArithmeticException.prototype).toHaveString("name");
	});

	it("should have a prototype property string named 'message'", () => {
		expect(ArithmeticException.prototype).toHaveString("message");
	});

	it("should have a prototype property string named 'code'", () => {
		expect(ArithmeticException.prototype).toHaveMember("code");
	});

    // :: EXTENDED PROTOTYPE

    // :: PROTOTYPE VALUES

    it("should have the 'class' name in the prototype property named 'name'", () => {
        expect(ArithmeticException.prototype.name).toEqual("ArithmeticException");
    });

    it("should have a dummy default value as message", () => {
        expect(ArithmeticException.prototype.message).toEqual("thrown");
    });

    it("should have a null default value as code", () => {
        expect(ArithmeticException.prototype.code).toBeNull();
    });

    // :: CONSTRUCTOR

    it("should instantiate without parameters", () => {
        let arg1, arg2, test;
        test = (() => new ArithmeticException(arg1, arg2));
        for (let i = 0; i < 2; i += 1) {
            for (let j = 0; j < 2; j += 1) {
                arg1 = (i % 2 === 0 ? undefined : null);
                arg2 = (j % 2 === 0 ? undefined : null);
                expect(test).not.toThrowError("parameter 'name' must be a 'string'");
                expect(test).not.toThrowError("parameter 'message' must be a 'string'");
                expect(test).not.toThrowError("parameter 'code' must be a 'number'");
            }
        }
        test = (() => new ArithmeticException());
        expect(test).not.toThrowError("parameter 'name' must be a 'string'");
        expect(test).not.toThrowError("parameter 'message' must be a 'string'");
        expect(test).not.toThrowError("parameter 'code' must be a 'number'");
    });

    it("should instantiate with parameters", () => {
        let arg1, arg2, test1, test2;
        const args1 = [undefined, null, ArithmeticException.prototype.message];
        const args2 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];
        test1       = (() => new ArithmeticException(arg1));
        test2       = (() => new ArithmeticException(arg1, arg2));
        for (let i = 0; i < args1.length; i += 1) {
            arg1 = args1[i];
            for (let j = 0; j < args2.length; j += 1) {
                arg2 = args2[j];
                expect(test2).not.toThrowError("parameter 'message' must be a 'string'");
                expect(test2).not.toThrowError("parameter 'code' must be a 'number'");
            }
            expect(test1).not.toThrowError("parameter 'message' must be a 'string'");
            expect(test1).not.toThrowError("parameter 'code' must be a 'number'");
        }
    });

    it("should throw an Error if 'message' or 'code' are invalid parameters", () => {
        let arg1, arg2, test21, test22, test11;
        const noStr = [{}, true, false, 42, 3.1416, -42, -3.1416, () => null];
        const noNmb = [{}, true, false, '', "qwerty", () => null];
        test22      = (() => new ArithmeticException(arg1, arg2));
        test21      = (() => new ArithmeticException(null, arg2));
        test11      = (() => new ArithmeticException(arg1));
        if (typeof Symbol === "function") {
            noStr.push(Symbol("symbol"));
            noNmb.push(Symbol("symbol"));
        }
        for (let i = 0; i < noStr.length; i += 1) {
            arg1 = noStr[i];
            for (let j = 0; j < noNmb.length; j += 1) {
                arg2 = noNmb[j];
                expect(test22).toThrowError("parameter 'message' must be a 'string'");
                expect(test21).toThrowError("parameter 'code' must be a 'number'");
            }
            expect(test11).toThrowError("parameter 'message' must be a 'string'");
        }
    });

    // :: MEMBER PROPERTIES

    it("should have all correct properties once instantiated", () => {
        const message = "asdf";
        const code    = Math.round(Math.random() * 0xFFFFFFFF);
        for (let i = 0; i < 2; i += 1) {
            const arg1    = (i % 2 === 0 ? message : null);
            const source1 = new ArithmeticException(arg1);
            for (let j = 0; j < 2; j += 1) {
                const arg2    = (j % 2 === 0 ? code : null);
                const source2 = new ArithmeticException(arg1, arg2);
                if (i % 2 === 0) {
                    expect(source1.message).toEqual(message);
                    expect(source2.message).toEqual(message);
                } else {
                    expect(source1.message).toEqual(ArithmeticException.prototype.message);
                    expect(source2.message).toEqual(ArithmeticException.prototype.message);
                }
                if (j % 2 === 0) {
                    expect(source2.code).toEqual(code);
                } else {
                    expect(source2.code).toBeNull();
                }
                expect(source1.code).toBeNull();
            }
        }
    });

    // :: MEMBER METHODS

    const name    = "ArithmeticException";

    const message = "asdf";
    const code    = Math.round(Math.random() * 0xFFFFFFFF);

    it("#toString()", () => {
        for (let i = 0; i < 2; i += 1) {
            const arg1    = (i % 2 === 0 ? message : null);
            const source1 = new ArithmeticException(arg1);
            for (let j = 0; j < 2; j += 1) {
                const arg2    = (j % 2 === 0 ? code : null);
                const source2 = new ArithmeticException(arg1, arg2);
                const str1    = source1.toString();
                const str2    = source2.toString();
                let exp1, exp2;
                exp1 = exp2 = "ArithmeticException";
                if (j % 2 === 0) {
                    exp2 += " (0x" + code.toString(16) + ')';
                }
                if (i % 2 === 0) {
                    exp1 += ": " + message + '.';
                    exp2 += ": " + message + '.';
                } else {
                    exp1 += ": " + ArithmeticException.prototype.message + '.';
                    exp2 += ": " + ArithmeticException.prototype.message + '.';
                }
                expect(str1).toEqual(exp1);
                expect(str2).toEqual(exp2);
            }
        }
    });

    it("#native()", () => {
        for (let i = 0; i < 2; i += 1) {
            const arg1    = (i % 2 === 0 ? message : null);
            const source1 = new ArithmeticException(arg1);
            for (let j = 0; j < 2; j += 1) {
                const arg2    = (j % 2 === 0 ? code : null);
                const source2 = new ArithmeticException(arg1, arg2);
                const err1    = source1.native();
                const err2    = source2.native();
                const exp1    = (i % 2 === 0 ? message : ArithmeticException.prototype.message);
                const exp2    = exp1;
                expect(err1).toEqual(new Error(exp1));
                expect(err2).toEqual(new Error(exp2));
            }
        }
    });

});

1			// spec/ArithmeticException.spec.js
2			"use strict";
3
4			// :: DEPENDENCIES
5
6			// load native dependencies
7			const path = require("path");
8
9			// load local dependencies
10			const root = path.dirname(__dirname);
11			const Throwable = require(path.join(root, "Throwable.js"));
12			const Exception = require(path.join(root, "Exception.js"));
13			const RuntimeException = require(path.join(root, "RuntimeException.js"));
14			const ArithmeticException = require(path.join(root, "ArithmeticException.js"));
15
16			// :: TESTING
17
18			// test the ArithmeticException 'class'
19			describe("ArithmeticException", () => {
20
21			// :: INHERITED PROTOTYPE
22
23			it("should inherit from 'Object'", () => {
24			expect(new ArithmeticException()).toEqual(jasmine.any(Object));
25			});
26
27			it("should inherit from 'Throwable'", () => {
28			expect(new ArithmeticException()).toEqual(jasmine.any(Throwable));
29			});
30
31			it("should inherit from 'Exception'", () => {
32			expect(new ArithmeticException()).toEqual(jasmine.any(Exception));
33			});
34
35			it("should inherit from 'RuntimeException'", () => {
36			expect(new ArithmeticException()).toEqual(jasmine.any(RuntimeException));
37			});
38
39			it("should have a prototype method named 'toString()'", () => {
40			expect(ArithmeticException.prototype).toHaveMethod("toString");
41			});
42
43			it("should have a prototype method named 'native()'", () => {
44			expect(ArithmeticException.prototype).toHaveMethod("native");
45			});
46
47			it("should have a prototype property string named 'name'", () => {
48			expect(ArithmeticException.prototype).toHaveString("name");
49			});
50
51			it("should have a prototype property string named 'message'", () => {
52			expect(ArithmeticException.prototype).toHaveString("message");
53			});
54
55			it("should have a prototype property string named 'code'", () => {
56			expect(ArithmeticException.prototype).toHaveMember("code");
57			});
58
59			// :: EXTENDED PROTOTYPE
60
61			// :: PROTOTYPE VALUES
62
63			it("should have the 'class' name in the prototype property named 'name'", () => {
64			expect(ArithmeticException.prototype.name).toEqual("ArithmeticException");
65			});
66
67			it("should have a dummy default value as message", () => {
68			expect(ArithmeticException.prototype.message).toEqual("thrown");
69			});
70
71			it("should have a null default value as code", () => {
72			expect(ArithmeticException.prototype.code).toBeNull();
73			});
74
75			// :: CONSTRUCTOR
76
77			it("should instantiate without parameters", () => {
78			let arg1, arg2, test;
79			test = (() => new ArithmeticException(arg1, arg2));
80			for (let i = 0; i < 2; i += 1) {
81			for (let j = 0; j < 2; j += 1) {
82			arg1 = (i % 2 === 0 ? undefined : null);
83			arg2 = (j % 2 === 0 ? undefined : null);
84			expect(test).not.toThrowError("parameter 'name' must be a 'string'");
85			expect(test).not.toThrowError("parameter 'message' must be a 'string'");
86			expect(test).not.toThrowError("parameter 'code' must be a 'number'");
87			}
88			}
89			test = (() => new ArithmeticException());
90			expect(test).not.toThrowError("parameter 'name' must be a 'string'");
91			expect(test).not.toThrowError("parameter 'message' must be a 'string'");
92			expect(test).not.toThrowError("parameter 'code' must be a 'number'");
93			});
94
95			it("should instantiate with parameters", () => {
96			let arg1, arg2, test1, test2;
97			const args1 = [undefined, null, ArithmeticException.prototype.message];
98			const args2 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];
99			test1 = (() => new ArithmeticException(arg1));
100			test2 = (() => new ArithmeticException(arg1, arg2));
101			for (let i = 0; i < args1.length; i += 1) {
102			arg1 = args1[i];
103			for (let j = 0; j < args2.length; j += 1) {
104			arg2 = args2[j];
105			expect(test2).not.toThrowError("parameter 'message' must be a 'string'");
106			expect(test2).not.toThrowError("parameter 'code' must be a 'number'");
107			}
108			expect(test1).not.toThrowError("parameter 'message' must be a 'string'");
109			expect(test1).not.toThrowError("parameter 'code' must be a 'number'");
110			}
111			});
112
113			it("should throw an Error if 'message' or 'code' are invalid parameters", () => {
114			let arg1, arg2, test21, test22, test11;
115			const noStr = [{}, true, false, 42, 3.1416, -42, -3.1416, () => null];
116			const noNmb = [{}, true, false, '', "qwerty", () => null];
117			test22 = (() => new ArithmeticException(arg1, arg2));
118			test21 = (() => new ArithmeticException(null, arg2));
119			test11 = (() => new ArithmeticException(arg1));
120			if (typeof Symbol === "function") {
121			noStr.push(Symbol("symbol"));
122			noNmb.push(Symbol("symbol"));
123			}
124			for (let i = 0; i < noStr.length; i += 1) {
125			arg1 = noStr[i];
126			for (let j = 0; j < noNmb.length; j += 1) {
127			arg2 = noNmb[j];
128			expect(test22).toThrowError("parameter 'message' must be a 'string'");
129			expect(test21).toThrowError("parameter 'code' must be a 'number'");
130			}
131			expect(test11).toThrowError("parameter 'message' must be a 'string'");
132			}
133			});
134
135			// :: MEMBER PROPERTIES
136
137			it("should have all correct properties once instantiated", () => {
138			const message = "asdf";
139			const code = Math.round(Math.random() * 0xFFFFFFFF);
140			for (let i = 0; i < 2; i += 1) {
141			const arg1 = (i % 2 === 0 ? message : null);
142			const source1 = new ArithmeticException(arg1);
143			for (let j = 0; j < 2; j += 1) {
144			const arg2 = (j % 2 === 0 ? code : null);
145			const source2 = new ArithmeticException(arg1, arg2);
146			if (i % 2 === 0) {
147			expect(source1.message).toEqual(message);
148			expect(source2.message).toEqual(message);
149			} else {
150			expect(source1.message).toEqual(ArithmeticException.prototype.message);
151			expect(source2.message).toEqual(ArithmeticException.prototype.message);
152			}
153			if (j % 2 === 0) {
154			expect(source2.code).toEqual(code);
155			} else {
156			expect(source2.code).toBeNull();
157			}
158			expect(source1.code).toBeNull();
159			}
160			}
161			});
162
163			// :: MEMBER METHODS
164
165			const name = "ArithmeticException";
			0 ignored issues – show Unused Code introduced 2017-06-10 15:49 UTC by Report Bug Copy Issue Report The constant `name` seems to be never used. Consider removing it. Loading history...
166			const message = "asdf";
167			const code = Math.round(Math.random() * 0xFFFFFFFF);
168
169			it("#toString()", () => {
170			for (let i = 0; i < 2; i += 1) {
171			const arg1 = (i % 2 === 0 ? message : null);
172			const source1 = new ArithmeticException(arg1);
173			for (let j = 0; j < 2; j += 1) {
174			const arg2 = (j % 2 === 0 ? code : null);
175			const source2 = new ArithmeticException(arg1, arg2);
176			const str1 = source1.toString();
177			const str2 = source2.toString();
178			let exp1, exp2;
179			exp1 = exp2 = "ArithmeticException";
180			if (j % 2 === 0) {
181			exp2 += " (0x" + code.toString(16) + ')';
182			}
183			if (i % 2 === 0) {
184			exp1 += ": " + message + '.';
185			exp2 += ": " + message + '.';
186			} else {
187			exp1 += ": " + ArithmeticException.prototype.message + '.';
188			exp2 += ": " + ArithmeticException.prototype.message + '.';
189			}
190			expect(str1).toEqual(exp1);
191			expect(str2).toEqual(exp2);
192			}
193			}
194			});
195
196			it("#native()", () => {
197			for (let i = 0; i < 2; i += 1) {
198			const arg1 = (i % 2 === 0 ? message : null);
199			const source1 = new ArithmeticException(arg1);
200			for (let j = 0; j < 2; j += 1) {
201			const arg2 = (j % 2 === 0 ? code : null);
202			const source2 = new ArithmeticException(arg1, arg2);
203			const err1 = source1.native();
204			const err2 = source2.native();
205			const exp1 = (i % 2 === 0 ? message : ArithmeticException.prototype.message);
206			const exp2 = exp1;
207			expect(err1).toEqual(new Error(exp1));
208			expect(err2).toEqual(new Error(exp2));
209			}
210			}
211			});
212
213			});

EgaLabs / node-ejsception

Push — master ( 057e84...5972c1 )

ArithmeticException.spec.js ➔ ??? B

Complexity

Size

Duplication

Importance

1 Function

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like